package com.ryskoo.permission.menu.service;

import com.ryskoo.framework.core.bean.QueryConditionEnum;
import com.ryskoo.framework.core.bean.QueryMessageDTO;
import com.ryskoo.framework.core.service.BasicServiceImpl;
import com.ryskoo.permission.menu.domain.MenuPO;
import com.ryskoo.permission.menu.repository.IMenuRepository;
import com.ryskoo.permission.permission.service.IPermissionService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author thq
 */
@Service
@Transactional
public class MenuServiceImpl extends BasicServiceImpl<MenuPO> implements IMenuService {

    private IMenuRepository menuRepository = null;

    @Autowired
    public void setMyDao(IMenuRepository dao) {
        this.menuRepository = dao;
        super.setDao(dao);
    }

    @Autowired
    private IPermissionService permissionService;

    /**
     * 根据菜单类型查询一级菜单
     *
     * @param menuType
     * @return
     */
    @Override
    public List<MenuPO> getMenus(String menuType, String parentId) {
        List<MenuPO> list = menuRepository.getMenus(menuType, parentId);
        // 根据搜索条件，递归查询下级菜单
        getAllMenus(list);
        return list;
    }

    /**
     * 根据条件查询菜单集合
     *
     * @param queryMessage
     * @return
     */
    @Override
    public List<MenuPO> getMenusByQueryMessage(QueryMessageDTO queryMessage) {
        List<MenuPO> list = this.queryByCondition(queryMessage);
        List<MenuPO> returnList = new ArrayList<MenuPO>();
        if (list != null && list.size() > 0) {
            for (MenuPO menuPO : list) {
                if (StringUtils.isEmpty(menuPO.getParentId())) {
                    returnList.add(menuPO);
                }
            }
            // 根据搜索条件，递归查询下级菜单
            getAllMenus(returnList);
        }

        return returnList;
    }

    /**
     * 查询树形结构菜单，如果是页面级菜单，则包含菜单关联的权限信息
     *
     * @param queryMessage 统一查询消息 {@link QueryMessageDTO}
     * @return 菜单列表 {@link List}&lt;{@link MenuPO}&gt;
     */
    @Override
    public List<MenuPO> getMenuWithPermission(QueryMessageDTO queryMessage) {
        queryMessage.addCondition("state", QueryConditionEnum.EQ.name(), "1");
        queryMessage.addSort("position", "ASC");
        List<MenuPO> list = this.queryByCondition(queryMessage);
        List<MenuPO> menuList = list.stream().filter(item -> StringUtils.isBlank(item.getParentId())).collect(Collectors.toList());
        for (MenuPO menu : menuList) {
            getSubMenus(menu, list);
        }
        return menuList;
    }

    /**
     * 根据管理员id获取此管理员可见的菜单列表
     * 菜单列表是包含上下级关系的树形结构
     *
     * @param managerId 管理员id
     * @param menuType  菜单类型  0：平台菜单  1：商户菜单
     * @return 菜单列表 {@link List}&lt;{@link MenuPO}&gt;
     */
    @Override
    public List<MenuPO> getMenuByManagerId(String managerId, int menuType) {
        List<MenuPO> menuList = menuRepository.getMenuByManagerId(managerId, menuType);
        //菜单去重
        List<MenuPO> newList = menuList.stream().distinct().collect(Collectors.toList());

//        List<MenuPO> firstMenus = menuList.stream().filter(item -> StringUtils.isBlank(item.getParentId())).collect(Collectors.toList());
//        for (MenuPO menu : firstMenus) {
//            getSubMenus(menu, menuList);
//        }
        return newList;
    }

    /**
     * 根据角色id获取此管理员可见的菜单列表
     * 菜单列表是包含上下级关系的树形结构
     *
     * @param roleId   角色id
     * @param menuType 菜单类型  0：平台菜单  1：商户菜单
     * @return 菜单列表 {@link List}&lt;{@link MenuPO}&gt;
     */
    @Override
    public List<MenuPO> getMenuTreeByRoleId(String roleId, int menuType) {
        List<MenuPO> menuList = menuRepository.getMenuByRoleId(roleId, menuType);
        List<MenuPO> firstMenus = menuList.stream().filter(item -> StringUtils.isBlank(item.getParentId())).collect(Collectors.toList());
        for (MenuPO menu : firstMenus) {
            getSubMenus(menu, menuList);
        }
        return firstMenus;
    }

    /**
     * 根据角色id获取此管理员可见的菜单列表，非树状结构
     *
     * @param roleId   角色id
     * @param menuType 菜单类型  0：平台菜单  1：商户菜单
     * @return
     */
    @Override
    public List<MenuPO> getMenuByRoleId(String roleId, int menuType) {
        return menuRepository.getMenuByRoleId(roleId, menuType);
    }

    public void getSubMenus(MenuPO menu, List<MenuPO> menuList) {
        List<MenuPO> chilrenList = menuList.stream().filter(item -> item.getParentId().equals(menu.getUuid())).collect(Collectors.toList());
        if (!chilrenList.isEmpty()) {
            menu.setChildrens(chilrenList);
            for (MenuPO chilren : chilrenList) {
                getSubMenus(chilren, menuList);
            }
        } else {
            QueryMessageDTO queryMessage = new QueryMessageDTO();
            queryMessage.addCondition("menuId", QueryConditionEnum.EQ.name(), menu.getUuid());
            menu.setPermissionList(permissionService.queryByCondition(queryMessage));
        }
    }

    /**
     * 递归获取子菜单
     *
     * @param list
     * @return
     */
    public List<MenuPO> getAllMenus(List<MenuPO> list) {
        if (list != null && list.size() > 0) {
            for (MenuPO menuPO : list) {
                List<MenuPO> chilrenList = menuRepository.getMenus("", menuPO.getUuid());
                menuPO.setChildrens(chilrenList);
                getAllMenus(chilrenList);
            }
        }
        return list;
    }
}
